TypeScript Express ஒருங்கிணைப்பு: பாதை கையாளுதல் வகை பாதுகாப்பு

TypeScript நவீன ஜாவாஸ்கிரிப்ட் மேம்பாட்டின் ஒரு மூலக்கல்லாக மாறியுள்ளது, இது குறியீடு தரம், பராமரிப்பு மற்றும் அளவிடுதல் ஆகியவற்றை மேம்படுத்தும் நிலையான தட்டச்சு திறன்களை வழங்குகிறது. பிரபலமான Node.js வலை பயன்பாட்டு கட்டமைப்பான Express.js உடன் இணைந்து, TypeScript உங்கள் பின்தள APIகளின் வலிமையை கணிசமாக மேம்படுத்த முடியும். இந்த விரிவான வழிகாட்டி, Express.js பயன்பாடுகளில் பாதை கையாளுதல் வகை பாதுகாப்பை அடைய TypeScript ஐ எவ்வாறு பயன்படுத்துவது என்பதை ஆராய்கிறது, உலகளாவிய பார்வையாளர்களுக்கான வலுவான மற்றும் பராமரிக்கக்கூடிய API களை உருவாக்குவதற்கான நடைமுறை எடுத்துக்காட்டுகள் மற்றும் சிறந்த நடைமுறைகளை வழங்குகிறது.

Express.js இல் ஏன் வகை பாதுகாப்பு முக்கியமானது

ஜாவாஸ்கிரிப்ட் போன்ற மாறும் மொழிகளில், பிழைகள் பெரும்பாலும் இயக்க நேரத்தில் பிடிக்கப்படுகின்றன, இது எதிர்பாராத நடத்தைக்கும், பிழைத்திருத்தம் செய்வதற்கும் கடினமான சிக்கல்களுக்கு வழிவகுக்கும். TypeScript நிலையான தட்டச்சு செய்வதன் மூலம் இதை நிவர்த்தி செய்கிறது, இது உற்பத்திக்கு வருவதற்கு முன்பு வளர்ச்சியின் போது பிழைகளை பிடிக்க உங்களை அனுமதிக்கிறது. Express.js இன் சூழலில், பாதை கையாளுபவர்களுக்கு வகை பாதுகாப்பு மிகவும் முக்கியமானது, அங்கு நீங்கள் கோரிக்கை மற்றும் பதில் பொருள்கள், வினவல் அளவுருக்கள் மற்றும் கோரிக்கை உடல்களுடன் கையாளுகிறீர்கள். இந்த உறுப்புகளை தவறாக கையாளுவது பயன்பாட்டு செயலிழப்புகள், தரவு சிதைவு மற்றும் பாதுகாப்பு பாதிப்புகளுக்கு வழிவகுக்கும்.

• ஆரம்ப பிழை கண்டறிதல்: வளர்ச்சியின் போது வகை தொடர்பான பிழைகளை பிடித்து, இயக்க நேர ஆச்சரியங்களின் சாத்தியக்கூறுகளை குறைக்கிறது.
• மேம்படுத்தப்பட்ட குறியீடு பராமரிப்பு: வகை சிறுகுறிப்புகள் குறியீட்டைப் புரிந்துகொள்வதற்கும் மீண்டும் உருவாக்குவதற்கும் எளிதாக்குகின்றன.
• மேம்படுத்தப்பட்ட குறியீடு நிறைவு மற்றும் கருவி: IDEகள் வகை தகவலுடன் சிறந்த பரிந்துரைகளையும் பிழை சரிபார்ப்பையும் வழங்க முடியும்.
• குறைக்கப்பட்ட பிழைகள்: வகை பாதுகாப்பு பொதுவான நிரலாக்க பிழைகளைத் தடுக்க உதவுகிறது, அதாவது செயல்பாடுகளுக்கு தவறான தரவு வகைகளை அனுப்புவது போன்றவை.

TypeScript Express.js திட்டத்தை அமைத்தல்

பாதை கையாளுதல் வகை பாதுகாப்பில் மூழ்குவதற்கு முன், ஒரு அடிப்படை TypeScript Express.js திட்டத்தை அமைப்போம். இது எங்கள் எடுத்துக்காட்டுகளுக்கு அடிப்படையாக இருக்கும்.

முன்தேவைகள்

• Node.js மற்றும் npm (Node Package Manager) நிறுவப்பட்டுள்ளன. அவற்றை அதிகாரப்பூர்வ Node.js இணையதளத்திலிருந்து பதிவிறக்கம் செய்யலாம். உகந்த இணக்கத்தன்மைக்கு உங்களிடம் சமீபத்திய பதிப்பு இருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்.
• Visual Studio Code போன்ற குறியீடு திருத்தி, இது சிறந்த TypeScript ஆதரவை வழங்குகிறது.

திட்ட துவக்கம்

1. புதிய திட்ட கோப்பகத்தை உருவாக்கவும்: mkdir typescript-express-app && cd typescript-express-app
2. புதிய npm திட்டத்தைத் தொடங்கவும்: npm init -y
3. TypeScript மற்றும் Express.js ஐ நிறுவவும்: npm install typescript express
4. Express.js க்கான TypeScript அறிவிப்பு கோப்புகளை நிறுவவும் (வகை பாதுகாப்புக்கு முக்கியமானது): npm install @types/express @types/node
5. TypeScript ஐத் தொடங்கவும்: npx tsc --init (இது tsconfig.json கோப்பை உருவாக்குகிறது, இது TypeScript கம்பைலரை கட்டமைக்கிறது.)

TypeScript ஐ கட்டமைத்தல்

tsconfig.json கோப்பைத் திறந்து அதை பொருத்தமாக கட்டமைக்கவும். இதோ ஒரு மாதிரி கட்டமைப்பு:

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

கவனிக்க வேண்டிய முக்கிய கட்டமைப்புகள்:

• target: ECMAScript இலக்கு பதிப்பைக் குறிப்பிடுகிறது. es6 ஒரு நல்ல தொடக்க புள்ளியாகும்.
• module: தொகுதி குறியீடு உருவாக்கத்தைக் குறிப்பிடுகிறது. Node.js க்கு commonjs ஒரு பொதுவான தேர்வாகும்.
• outDir: தொகுக்கப்பட்ட ஜாவாஸ்கிரிப்ட் கோப்புகளுக்கான வெளியீட்டு கோப்பகத்தைக் குறிப்பிடுகிறது.
• rootDir: உங்கள் TypeScript மூலக் கோப்புகளின் ரூட் கோப்பகத்தைக் குறிப்பிடுகிறது.
• strict: மேம்பட்ட வகை பாதுகாப்புக்கான அனைத்து கண்டிப்பான வகை சரிபார்ப்பு விருப்பங்களையும் செயல்படுத்துகிறது. இது மிகவும் பரிந்துரைக்கப்படுகிறது.
• esModuleInterop: CommonJS மற்றும் ES தொகுதிகளுக்கு இடையில் செயல்படுவதை செயல்படுத்துகிறது.

நுழைவு புள்ளியை உருவாக்குதல்

src கோப்பகத்தை உருவாக்கி, index.ts கோப்பைச் சேர்க்கவும்:

mkdir src
touch src/index.ts

src/index.ts ஐ ஒரு அடிப்படை Express.js சர்வர் அமைப்புடன் நிரப்பவும்:

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

app.get('/', (req: Request, res: Response) => {
  res.send('Hello, TypeScript Express!');
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

ஒரு கட்டளை வரியை சேர்த்தல்

TypeScript குறியீட்டை தொகுக்க உங்கள் package.json கோப்பில் ஒரு கட்டளை வரியைச் சேர்க்கவும்:

"scripts": {
  "build": "tsc",
  "start": "node dist/index.js",
  "dev": "npm run build && npm run start"
}

இப்போது நீங்கள் சர்வரை உருவாக்க மற்றும் தொடங்க npm run dev ஐ இயக்கலாம்.

பாதை கையாளுதல் வகை பாதுகாப்பு: கோரிக்கை மற்றும் பதில் வகைகளை வரையறுத்தல்

பாதை கையாளுதல் வகை பாதுகாப்பின் மையமானது Request மற்றும் Response பொருள்களுக்கான வகைகளை சரியாக வரையறுப்பதில் உள்ளது. Express.js இந்த பொருள்களுக்கான பொதுவான வகைகளை வழங்குகிறது, இது வினவல் அளவுருக்கள், கோரிக்கை உடல் மற்றும் பாதை அளவுருக்களின் வகைகளை நீங்கள் குறிப்பிட அனுமதிக்கிறது.

அடிப்படை பாதை கையாளுதல் வகைகள்

ஒரு பெயரை வினவல் அளவுருவாக எதிர்பார்க்கும் ஒரு எளிய பாதை கையாளுதலுடன் ஆரம்பிக்கலாம்:

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

interface NameQuery {
  name: string;
}

app.get('/hello', (req: Request, res: Response) => {
  const name = req.query.name;

  if (!name) {
    return res.status(400).send('Name parameter is required.');
  }

  res.send(`Hello, ${name}!`);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

இந்த எடுத்துக்காட்டில்:

• Request<any, any, any, NameQuery> கோரிக்கை பொருளுக்கான வகையை வரையறுக்கிறது.
• முதல் any பாதை அளவுருக்களைக் குறிக்கிறது (எ.கா., /users/:id).
• இரண்டாவது any பதில் உடல் வகையைக் குறிக்கிறது.
• மூன்றாவது any கோரிக்கை உடல் வகையைக் குறிக்கிறது.
• NameQuery என்பது வினவல் அளவுருக்களின் கட்டமைப்பை வரையறுக்கும் ஒரு இடைமுகம்.

NameQuery இடைமுகத்தை வரையறுப்பதன் மூலம், req.query.name சொத்து இருக்கிறதா மற்றும் string வகையா என்பதை TypeScript இப்போது சரிபார்க்க முடியும். நீங்கள் இல்லாத சொத்தை அணுக அல்லது தவறான வகையின் மதிப்பை ஒதுக்க முயற்சித்தால், TypeScript ஒரு பிழையைக் குறிக்கும்.

கோரிக்கை உடல்களை கையாளுதல்

கோரிக்கை உடல்களை ஏற்கும் பாதைகளுக்கு (எ.கா., POST, PUT, PATCH), நீங்கள் கோரிக்கை உடலுக்கான ஒரு இடைமுகத்தை வரையறுத்து அதை Request வகைகளில் பயன்படுத்தலாம்:

import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';

const app = express();
const port = 3000;

app.use(bodyParser.json()); // JSON கோரிக்கை உடல்களை பாகுபடுத்த முக்கியம்

interface CreateUserRequest {
  firstName: string;
  lastName: string;
  email: string;
}

app.post('/users', (req: Request, res: Response) => {
  const { firstName, lastName, email } = req.body;

  // கோரிக்கை உடலை சரிபார்க்கவும்
  if (!firstName || !lastName || !email) {
    return res.status(400).send('Missing required fields.');
  }

  // பயனர் உருவாக்கத்தை செயலாக்கவும் (எ.கா., தரவுத்தளத்தில் சேமிக்கவும்)
  console.log(`Creating user: ${firstName} ${lastName} (${email})`);

  res.status(201).send('User created successfully.');
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

இந்த எடுத்துக்காட்டில்:

• CreateUserRequest எதிர்பார்க்கப்படும் கோரிக்கை உடலின் கட்டமைப்பை வரையறுக்கிறது.
• app.use(bodyParser.json()) JSON கோரிக்கை உடல்களை பாகுபடுத்த முக்கியமானது. அது இல்லாமல், req.body வரையறுக்கப்படாமல் இருக்கும்.
• Request வகை இப்போது Request<any, any, CreateUserRequest>, கோரிக்கை உடல் CreateUserRequest இடைமுகத்திற்கு இணங்க வேண்டும் என்று குறிப்பிடுகிறது.

req.body பொருள் எதிர்பார்க்கப்படும் பண்புகளை (firstName, lastName, மற்றும் email) கொண்டுள்ளது மற்றும் அவற்றின் வகைகள் சரியானவை என்பதை TypeScript இப்போது உறுதி செய்யும். இது தவறான கோரிக்கை உடல் தரவுகளால் ஏற்படும் இயக்க நேர பிழைகளின் அபாயத்தை கணிசமாகக் குறைக்கிறது.

பாதை அளவுருக்களை கையாளுதல்

அளவுருக்களைக் கொண்ட பாதைகளுக்கு (எ.கா., /users/:id), நீங்கள் பாதை அளவுருக்களுக்கு ஒரு இடைமுகத்தை வரையறுத்து அதை Request வகைகளில் பயன்படுத்தலாம்:

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

interface UserParams {
  id: string;
}

interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
}

const users: User[] = [
  { id: '1', firstName: 'John', lastName: 'Doe', email: 'john.doe@example.com' },
  { id: '2', firstName: 'Jane', lastName: 'Smith', email: 'jane.smith@example.com' },
];

app.get('/users/:id', (req: Request, res: Response) => {
  const userId = req.params.id;

  const user = users.find(u => u.id === userId);

  if (!user) {
    return res.status(404).send('User not found.');
  }

  res.json(user);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

இந்த எடுத்துக்காட்டில்:

• UserParams பாதை அளவுருக்களின் கட்டமைப்பை வரையறுக்கிறது, id அளவுரு ஒரு சரமாக இருக்க வேண்டும் என்று குறிப்பிடுகிறது.
• Request வகை இப்போது Request<UserParams>, req.params பொருள் UserParams இடைமுகத்திற்கு இணங்க வேண்டும் என்று குறிப்பிடுகிறது.

req.params.id சொத்து இருக்கிறதா மற்றும் string வகையா என்பதை TypeScript இப்போது உறுதி செய்யும். இல்லாத பாதை அளவுருக்களை அணுகுவதால் அல்லது அவற்றை தவறான வகைகளுடன் பயன்படுத்துவதால் ஏற்படும் பிழைகளைத் தடுக்க இது உதவுகிறது.

பதில் வகைகளை குறிப்பிடுதல்

கோரிக்கை வகை பாதுகாப்பில் கவனம் செலுத்துவது முக்கியம் என்றாலும், பதில் வகைகளை வரையறுப்பது குறியீடு தெளிவை மேம்படுத்துகிறது மற்றும் முரண்பாடுகளைத் தடுக்க உதவுகிறது. பதிலில் நீங்கள் திரும்ப அனுப்பும் தரவின் வகையை நீங்கள் வரையறுக்கலாம்.

import express, { Request, Response } from 'express';

const app = express();
const port = 3000;

interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
}

const users: User[] = [
  { id: '1', firstName: 'John', lastName: 'Doe', email: 'john.doe@example.com' },
  { id: '2', firstName: 'Jane', lastName: 'Smith', email: 'jane.smith@example.com' },
];

app.get('/users', (req: Request, res: Response) => {
    res.json(users);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

இங்கே, Response<User[]> பதில் உடல் User பொருள்களின் வரிசையாக இருக்க வேண்டும் என்று குறிப்பிடுகிறது. உங்கள் API பதில்களில் சரியான தரவு கட்டமைப்பை தொடர்ந்து அனுப்புகிறீர்கள் என்பதை உறுதிப்படுத்த இது உதவுகிறது. User[] வகைக்கு இணங்காத தரவை அனுப்ப முயற்சித்தால், TypeScript ஒரு எச்சரிக்கையை வழங்கும்.

இடைநிலை வகை பாதுகாப்பு

Express.js பயன்பாடுகளில் குறுக்கு வெட்டு கவலைகளை கையாள்வதற்கு இடைநிலை செயல்பாடுகள் அவசியம். இடைநிலையில் வகை பாதுகாப்பை உறுதி செய்வது பாதை கையாளுபவர்களில் இருப்பதைப் போலவே முக்கியமானது.

இடைநிலை செயல்பாடுகளை தட்டச்சு செய்தல்

TypeScript இல் ஒரு இடைநிலை செயல்பாட்டின் அடிப்படை அமைப்பு ஒரு பாதை கையாளுபவரின் அமைப்பைப் போன்றது:

import express, { Request, Response, NextFunction } from 'express';

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // அங்கீகார தர்க்கம்
  const isAuthenticated = true; // உண்மையான அங்கீகார சரிபார்ப்புடன் மாற்றவும்

  if (isAuthenticated) {
    next(); // அடுத்த இடைநிலை அல்லது பாதை கையாளுபவருக்கு தொடரவும்
  } else {
    res.status(401).send('Unauthorized');
  }
}

const app = express();
const port = 3000;

app.use(authenticationMiddleware);

app.get('/', (req: Request, res: Response) => {
  res.send('Hello, authenticated user!');
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

இந்த எடுத்துக்காட்டில்:

• NextFunction என்பது Express.js ஆல் வழங்கப்பட்ட ஒரு வகை, இது சங்கிலியில் உள்ள அடுத்த இடைநிலை செயல்பாட்டைக் குறிக்கிறது.
• இடைநிலை செயல்பாடு பாதை கையாளுபவர்களைப் போலவே Request மற்றும் Response பொருள்களை எடுக்கும்.

கோரிக்கை பொருளை அதிகரித்தல்

சில நேரங்களில், உங்கள் இடைநிலையில் Request பொருளில் தனிப்பயன் பண்புகளைச் சேர்க்க விரும்பலாம். எடுத்துக்காட்டாக, ஒரு அங்கீகார இடைநிலை கோரிக்கை பொருளில் user பண்பைச் சேர்க்கலாம். இதை ஒரு வகை-பாதுகாப்பான வழியில் செய்ய, நீங்கள் Request இடைமுகத்தை அதிகரிக்க வேண்டும்.

import express, { Request, Response, NextFunction } from 'express';

interface User {
  id: string;
  username: string;
  email: string;
}

// கோரிக்கை இடைமுகத்தை அதிகரிக்கவும்
declare global {
  namespace Express {
    interface Request {
      user?: User;
    }
  }
}

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // அங்கீகார தர்க்கம் (உண்மையான அங்கீகார சரிபார்ப்புடன் மாற்றவும்)
  const user: User = { id: '123', username: 'johndoe', email: 'john.doe@example.com' };
  req.user = user; // கோரிக்கை பொருளுக்கு பயனரைச் சேர்க்கவும்
  next(); // அடுத்த இடைநிலை அல்லது பாதை கையாளுபவருக்கு தொடரவும்
}

const app = express();
const port = 3000;

app.use(authenticationMiddleware);

app.get('/', (req: Request, res: Response) => {
  const username = req.user?.username || 'Guest';
  res.send(`Hello, ${username}!`);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

இந்த எடுத்துக்காட்டில்:

• Express.Request இடைமுகத்தை அதிகரிக்க ஒரு உலகளாவிய அறிவிப்பைப் பயன்படுத்துகிறோம்.
• Request இடைமுகத்தில் User வகையின் விருப்பமான user பண்பைச் சேர்க்கிறோம்.
• இப்போது, TypeScript புகார் செய்யாமல் உங்கள் பாதை கையாளுபவர்களில் req.user பண்பை நீங்கள் அணுகலாம். பயனருக்கு அங்கீகாரம் இல்லாத நிகழ்வுகளை கையாள்வதற்கு req.user?.username இல் உள்ள `?` முக்கியமானது, சாத்தியமான பிழைகளைத் தடுக்கிறது.

TypeScript Express ஒருங்கிணைப்பிற்கான சிறந்த நடைமுறைகள்

உங்கள் Express.js பயன்பாடுகளில் TypeScript இன் நன்மைகளை அதிகரிக்க, இந்த சிறந்த நடைமுறைகளைப் பின்பற்றவும்:

• கண்டிப்பான பயன்முறையை இயக்கவும்: உங்கள் tsconfig.json கோப்பில் "strict": true விருப்பத்தைப் பயன்படுத்தி, அனைத்து கண்டிப்பான வகை சரிபார்ப்பு விருப்பங்களையும் இயக்கவும். இது சாத்தியமான பிழைகளை முன்கூட்டியே பிடிக்க உதவுகிறது மற்றும் அதிக அளவிலான வகை பாதுகாப்பை உறுதி செய்கிறது.
• இடைமுகங்கள் மற்றும் வகை மாற்றுப்பெயர்களைப் பயன்படுத்தவும்: உங்கள் தரவின் கட்டமைப்பைக் குறிக்க இடைமுகங்கள் மற்றும் வகை மாற்றுப்பெயர்களை வரையறுக்கவும். இது உங்கள் குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் ஆக்குகிறது.
• பொதுவான வகைகளைப் பயன்படுத்தவும்: மீண்டும் பயன்படுத்தக்கூடிய மற்றும் வகை-பாதுகாப்பான கூறுகளை உருவாக்க பொதுவான வகைகளைப் பயன்படுத்தவும்.
• அலகு சோதனைகளை எழுதுங்கள்: உங்கள் குறியீட்டின் சரியான தன்மையைச் சரிபார்க்கவும், உங்கள் வகை சிறுகுறிப்புகள் துல்லியமானவை என்பதை உறுதிப்படுத்தவும் அலகு சோதனைகளை எழுதுங்கள். குறியீட்டு தரத்தை பராமரிக்க சோதனை முக்கியமானது.
• ஒரு லென்டர் மற்றும் ஃபார்மேட்டரைப் பயன்படுத்தவும்: நிலையான குறியீட்டு பாணிகளைச் செயல்படுத்தவும், சாத்தியமான பிழைகளை பிடிக்கவும் ஒரு லென்டர் (ESLint போன்றவை) மற்றும் ஒரு ஃபார்மேட்டர் (Prettier போன்றவை) பயன்படுத்தவும்.
• any வகையைத் தவிர்க்கவும்: any வகையின் பயன்பாட்டைக் குறைக்கவும், ஏனெனில் இது வகை சரிபார்ப்பை புறக்கணிக்கிறது மற்றும் TypeScript ஐப் பயன்படுத்துவதன் நோக்கத்தைத் தோற்கடிக்கிறது. முற்றிலும் அவசியமான போது மட்டுமே பயன்படுத்தவும், மேலும் சாத்தியமான போதெல்லாம் மிகவும் குறிப்பிட்ட வகைகள் அல்லது ஜெனரிக்குகளைப் பயன்படுத்த கருதுங்கள்.
• உங்கள் திட்டத்தை தர்க்கரீதியாக கட்டமைக்கவும்: செயல்பாட்டின் அடிப்படையில் உங்கள் திட்டத்தை தொகுதிகள் அல்லது கோப்புறைகளாக ஒழுங்கமைக்கவும். இது உங்கள் பயன்பாட்டின் பராமரிப்பு மற்றும் அளவிடுதலை மேம்படுத்தும்.
• சார்பு ஊசி பயன்படுத்தவும்: உங்கள் பயன்பாட்டின் சார்புகளை நிர்வகிக்க ஒரு சார்பு ஊசி கொள்கலனைப் பயன்படுத்த கருதுங்கள். இது உங்கள் குறியீட்டை மேலும் சோதிக்கக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் மாற்றும். InversifyJS போன்ற நூலகங்கள் பிரபலமான தேர்வுகள்.

Express.js க்கான மேம்பட்ட TypeScript கருத்துகள்

அலங்காரங்களைப் பயன்படுத்துதல்

அலங்காரங்கள் வகுப்புகள் மற்றும் செயல்பாடுகளுக்கு மெட்டாடேட்டாவைச் சேர்ப்பதற்கு ஒரு சுருக்கமான மற்றும் வெளிப்படையான வழியை வழங்குகின்றன. Express.js இல் பாதை பதிவை எளிதாக்க அலங்காரங்களைப் பயன்படுத்தலாம்.

முதலில், compilerOptions க்கு "experimentalDecorators": true ஐச் சேர்ப்பதன் மூலம் உங்கள் tsconfig.json கோப்பில் சோதனை அலங்காரங்களை இயக்க வேண்டும்.

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "experimentalDecorators": true
  }
}

பின்னர், பாதைகளைப் பதிவு செய்ய ஒரு தனிப்பயன் அலங்காரத்தை உருவாக்கலாம்:

import express, { Router, Request, Response } from 'express';

function route(method: string, path: string) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    if (!target.__router__) {
      target.__router__ = Router();
    }

    target.__router__[method](path, descriptor.value);
  };
}

class UserController {
  @route('get', '/users')
  getUsers(req: Request, res: Response) {
    res.send('List of users');
  }

  @route('post', '/users')
  createUser(req: Request, res: Response) {
    res.status(201).send('User created');
  }

  public getRouter() {
    return this.__router__;
  }
}

const userController = new UserController();

const app = express();
const port = 3000;

app.use('/', userController.getRouter());

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});

இந்த எடுத்துக்காட்டில்:

• route அலங்கரிப்பான் HTTP முறை மற்றும் பாதையை வாதங்களாக எடுக்கும்.
• இது அலங்கரிக்கப்பட்ட முறையை வகுப்போடு தொடர்புடைய ரூட்டரில் ஒரு பாதை கையாளுபவராகப் பதிவு செய்கிறது.
• இது பாதை பதிவை எளிதாக்குகிறது மற்றும் உங்கள் குறியீட்டை மேலும் படிக்கக்கூடியதாக ஆக்குகிறது.

தனிப்பயன் வகை பாதுகாவலர்களைப் பயன்படுத்துதல்

வகை பாதுகாவலர்கள் ஒரு குறிப்பிட்ட எல்லைக்குள் ஒரு மாறியின் வகையை குறைக்கும் செயல்பாடுகள். கோரிக்கை உடல்கள் அல்லது வினவல் அளவுருக்களை சரிபார்க்க தனிப்பயன் வகை பாதுகாவலர்களைப் பயன்படுத்தலாம்.

interface Product {
    id: string;
    name: string;
    price: number;
}

function isProduct(obj: any): obj is Product {
    return typeof obj === 'object' &&
           obj !== null &&
           typeof obj.id === 'string' &&
           typeof obj.name === 'string' &&
           typeof obj.price === 'number';
}

import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';

const app = express();
const port = 3000;

app.use(bodyParser.json());

app.post('/products', (req: Request, res: Response) => {
    if (!isProduct(req.body)) {
        return res.status(400).send('Invalid product data');
    }

    const product: Product = req.body;
    console.log(`Creating product: ${product.name}`);
    res.status(201).send('Product created');
});

app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}`);
});

இந்த எடுத்துக்காட்டில்:

• isProduct செயல்பாடு ஒரு தனிப்பயன் வகை பாதுகாவலர், இது ஒரு பொருள் Product இடைமுகத்துடன் ஒத்துப்போகிறதா என்பதை சரிபார்க்கிறது.
• /products பாதை கையாளுபவருக்குள், isProduct செயல்பாடு கோரிக்கை உடலை சரிபார்க்க பயன்படுத்தப்படுகிறது.
• கோரிக்கை உடல் ஒரு சரியான தயாரிப்பு என்றால், if தொகுதிக்குள் req.body Product வகையைச் சேர்ந்தது என்று TypeScript க்குத் தெரியும்.

API வடிவமைப்பில் உலகளாவிய பரிசீலனைகளை உரையாற்றுதல்

உலகளாவிய பார்வையாளர்களுக்கான API களை வடிவமைக்கும்போது, அணுகல், பயன்பாடு மற்றும் கலாச்சார உணர்திறன் ஆகியவற்றை உறுதிப்படுத்த பல காரணிகளைக் கருத்தில் கொள்ள வேண்டும்.

• உள்ளூர்மயமாக்கல் மற்றும் சர்வதேசமயமாக்கல் (i18n மற்றும் L10n):
  • உள்ளடக்க பேச்சுவார்த்தை: Accept-Language ஹெடரை அடிப்படையாகக் கொண்ட உள்ளடக்க பேச்சுவார்த்தை மூலம் பல மொழிகள் மற்றும் பிராந்தியங்களை ஆதரிக்கவும்.
  • தேதி மற்றும் நேர வடிவமைப்பு: வெவ்வேறு பிராந்தியங்களில் தெளிவின்மையைத் தவிர்க்க தேதி மற்றும் நேர பிரதிநிதித்துவத்திற்கு ISO 8601 வடிவமைப்பைப் பயன்படுத்தவும்.
  • எண் வடிவமைப்பு: பயனரின் லோகேலுக்கு ஏற்ப எண் வடிவமைப்பைக் கையாளவும் (எ.கா., தசம பிரிப்பான்கள் மற்றும் ஆயிரம் பிரிப்பான்கள்).
  • நாணய கையாளுதல்: பல நாணயங்களை ஆதரிக்கவும், தேவைப்பட்டால் மாற்று விகித தகவலை வழங்கவும்.
  • உரை திசை: அரபு மற்றும் ஹீப்ரு போன்ற வலமிருந்து இடமாக (RTL) மொழிகளைப் பயன்படுத்தவும்.
• நேர மண்டலங்கள்:
  • சர்வ வல்லமையுள்ள நேரத்தில் (UTC) தேதிகளையும் நேரங்களையும் சேவையக பக்கத்தில் சேமிக்கவும்.
  • தங்களுக்கு விருப்பமான நேர மண்டலத்தைக் குறிப்பிட பயனர்களை அனுமதிக்கவும், அதன்படி கிளையன்ட் பக்கத்தில் தேதிகளையும் நேரங்களையும் மாற்றவும்.
  • நேர மண்டல மாற்றங்களைக் கையாள moment-timezone போன்ற நூலகங்களைப் பயன்படுத்தவும்.
• எழுத்து குறியாக்கம்:
  • வெவ்வேறு மொழிகளிலிருந்து பரவலான எழுத்துக்களை ஆதரிக்க அனைத்து உரை தரவிற்கும் UTF-8 குறியாக்கத்தைப் பயன்படுத்தவும்.
  • உங்கள் தரவுத்தளம் மற்றும் பிற தரவு சேமிப்பக அமைப்புகள் UTF-8 ஐப் பயன்படுத்த கட்டமைக்கப்பட்டுள்ளதை உறுதிப்படுத்திக் கொள்ளுங்கள்.
• அணுகல்தன்மை:
  • ஊனமுற்ற பயனர்களுக்கு உங்கள் API ஐ அணுகக்கூடியதாக மாற்ற அணுகல்தன்மை வழிகாட்டுதல்களைப் (எ.கா., WCAG) பின்பற்றவும்.
  • புரிந்துகொள்ள எளிதான தெளிவான மற்றும் விளக்கமான பிழை செய்திகளை வழங்கவும்.
  • உங்கள் API ஆவணத்தில் சொற்பொருள் HTML கூறுகள் மற்றும் ARIA பண்புகளைப் பயன்படுத்தவும்.
• கலாச்சார உணர்திறன்:
  • அனைத்து பயனர்களுக்கும் புரியாத கலாச்சார குறிப்பிட்ட குறிப்புகள், மரபுகள் அல்லது நகைச்சுவைகளைப் பயன்படுத்துவதைத் தவிர்க்கவும்.
  • தகவல் தொடர்பு பாணிகள் மற்றும் விருப்பங்களில் கலாச்சார வேறுபாடுகளை மனதில் கொள்ளுங்கள்.
  • வெவ்வேறு கலாச்சார குழுக்களில் உங்கள் API இன் சாத்தியமான தாக்கத்தைக் கருத்தில் கொண்டு, தவறான கருத்துகளை அல்லது பாரபட்சங்களை நிலைநிறுத்துவதைத் தவிர்க்கவும்.
• தரவு தனியுரிமை மற்றும் பாதுகாப்பு:
  • GDPR (பொது தரவு பாதுகாப்பு ஒழுங்குமுறை) மற்றும் CCPA (கலிபோர்னியா நுகர்வோர் தனியுரிமைச் சட்டம்) போன்ற தரவு தனியுரிமை ஒழுங்குமுறைகளுக்கு இணங்கவும்.
  • பயனர் தரவைப் பாதுகாக்க வலுவான அங்கீகாரம் மற்றும் அங்கீகார வழிமுறைகளை செயல்படுத்தவும்.
  • போக்குவரத்தில் மற்றும் ஓய்வில் இருக்கும் போது முக்கியமான தரவை குறியாக்கம் செய்யவும்.
  • பயனர்களுக்கு அவர்களின் தரவின் மீது கட்டுப்பாட்டை வழங்குங்கள் மற்றும் அவர்களின் தரவை அணுகவும், மாற்றவும் மற்றும் நீக்கவும் அனுமதிக்கவும்.
• API ஆவணம்:
  • புரிந்து கொள்ளவும் செல்லவும் எளிதான விரிவான மற்றும் நன்கு ஒழுங்கமைக்கப்பட்ட API ஆவணத்தை வழங்கவும்.
  • ஊடாடும் API ஆவணத்தை உருவாக்க Swagger/OpenAPI போன்ற கருவிகளைப் பயன்படுத்தவும்.
  • பல்வேறு பார்வையாளர்களைப் பூர்த்தி செய்ய பல நிரலாக்க மொழிகளில் குறியீடு எடுத்துக்காட்டுகளைச் சேர்க்கவும்.
  • பரந்த பார்வையாளர்களை அடைய உங்கள் API ஆவணத்தை பல மொழிகளில் மொழிபெயர்க்கவும்.
• பிழை கையாளுதல்:
  • குறிப்பிட்ட மற்றும் தகவல் பிழை செய்திகளை வழங்கவும். "ஏதோ தவறு நடந்தது" போன்ற பொதுவான பிழை செய்திகளைத் தவிர்க்கவும்.
  • பிழையின் வகையைக் குறிக்க நிலையான HTTP நிலை குறியீடுகளைப் பயன்படுத்தவும் (எ.கா., மோசமான கோரிக்கைக்கான 400, அங்கீகரிக்கப்படாததற்கான 401, உள் சேவையக பிழைக்கான 500).
  • சிக்கல்களைக் கண்காணிக்கவும் பிழைத்திருத்தவும் பயன்படுத்தக்கூடிய பிழை குறியீடுகள் அல்லது அடையாளங்காட்டிகளைச் சேர்க்கவும்.
  • பிழைத்திருத்தம் மற்றும் கண்காணிப்புக்காக சேவையக பக்கத்தில் பிழைகளைப் பதிவு செய்யவும்.
• விகித வரம்பு: உங்கள் API ஐ துஷ்பிரயோகத்திலிருந்து பாதுகாக்க மற்றும் நியாயமான பயன்பாட்டை உறுதிப்படுத்த விகித வரம்பை செயல்படுத்தவும்.
• பதிப்பு கட்டுப்பாடு: பின்னோக்கி இணக்கமான மாற்றங்களை அனுமதிக்கவும் ஏற்கனவே உள்ள வாடிக்கையாளர்களை உடைப்பதைத் தவிர்க்கவும் API பதிப்பு கட்டுப்பாட்டைப் பயன்படுத்தவும்.

முடிவுரை

TypeScript Express ஒருங்கிணைப்பு உங்கள் பின்தள APIகளின் நம்பகத்தன்மை மற்றும் பராமரிப்பை கணிசமாக மேம்படுத்துகிறது. பாதை கையாளுபவர்கள் மற்றும் இடைநிலையில் வகை பாதுகாப்பைப் பயன்படுத்துவதன் மூலம், மேம்பாட்டு செயல்பாட்டின் ஆரம்பத்தில் பிழைகளைப் பிடித்து உலகளாவிய பார்வையாளர்களுக்கான வலுவான மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்கலாம். கோரிக்கை மற்றும் பதில் வகைகளை வரையறுப்பதன் மூலம், உங்கள் API ஒரு நிலையான தரவு கட்டமைப்பைப் பின்பற்றுகிறது என்பதை உறுதிசெய்கிறீர்கள், இது இயக்க நேர பிழைகளின் சாத்தியக்கூறுகளைக் குறைக்கிறது. கண்டிப்பான பயன்முறையை இயக்குதல், இடைமுகங்கள் மற்றும் வகை மாற்றுப்பெயர்களைப் பயன்படுத்துதல் மற்றும் TypeScript இன் நன்மைகளை அதிகரிக்க அலகு சோதனைகளை எழுதுதல் போன்ற சிறந்த நடைமுறைகளை கடைபிடிக்க நினைவில் கொள்ளுங்கள். உங்கள் APIகள் உலகளவில் அணுகக்கூடியதாகவும் பயன்படுத்தக்கூடியதாகவும் இருப்பதை உறுதிப்படுத்த உள்ளூர்மயமாக்கல், நேர மண்டலங்கள் மற்றும் கலாச்சார உணர்திறன் போன்ற உலகளாவிய காரணிகளை எப்போதும் கருத்தில் கொள்ளுங்கள்.